/*package net.mysoft.framework.util;

import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

import org.apache.struts2.ServletActionContext;

import sun.net.TelnetInputStream;
import sun.net.TelnetOutputStream;
import sun.net.ftp.FtpClient;

*//**
 * ftp上传，下载
 * 
 * 
 * @author liuyang 2012-04-25
 * 
 * 
 *//*
public class FtpUtil {
	*//**
	 * FTP服务器IP
	 *//*
	private String ip = "";
	*//**
	 * 用户名
	 *//*
	private String username = "";
	*//**
	 * 密码
	 *//*
	private String password = "";
	*//**
	 * FTP服务器端口
	 *//*
	private int port = 21;
	*//**
	 * 根目录
	 *//*
	private String path = "";
	*//**
	 * 将文档路径和文档名存放在map中，进行数据库存储
	 *//*
	private Map<String, String> mapPathName;
	FtpClient ftpClient = null;
	OutputStream os = null;
	FileInputStream is = null;

	public FtpUtil() {
	}

	public FtpUtil(String ip, int port, String username, String password) {
		this.ip = ip;
		this.username = username;
		this.password = password;
		this.port = port;
	}

	public FtpUtil(String ip, int port, String username, String password,
			String defaulPath) {
		this.ip = ip;
		this.username = username;
		this.password = password;
		this.port = port;
		this.path = defaulPath;
	}

	
	 * public static void main(String[] args) throws Exception{ FtpUtil f = new
	 * FtpUtil(); f.connectServer(); f.uploadFile("C:/1011评级历史比较.xls",
	 * "aaa/bb",".xls"); }
	 

	*//**
	 * @param localPath
	 *            当前文件路径
	 * @param baseServicePath
	 *            服务器存放路径
	 * @param nameSuffix
	 *            指定后缀名，如不指定沿用当前文件的后缀名
	 * @return List Map(用户查看文件名，数据库存放的路径)
	 *//*
	public List<Map<String, Object>> uploadFile(String localPath,
			String baseServicePath, String nameSuffix) {
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		String strServicePath = "";
		connectServer();// 连接ftp
		boolean blCreateDir = createDir(baseServicePath);
		if (blCreateDir) {
			Map<String, Object> mapData = new HashMap<String, Object>();
			// 如果没有指定后缀名，则沿用当前文件的后缀名
			if ("".equals(nameSuffix))
				nameSuffix = localPath.substring(localPath.lastIndexOf("."));
			strServicePath = baseServicePath + "/" + new Date().getTime()
					+ nameSuffix;
			upFile(localPath, "/" + this.path + "/" + strServicePath);// 上传到ftp
			mapData.put("ServicePath", strServicePath);
			list.add(mapData);
		}
		closeServer();
		return list;
	}

	*//**
	 * @param localPath
	 *            当前文件路径
	 * @param baseServicePath
	 *            服务器存放路径
	 * @param nameSuffix
	 *            指定后缀名，如不指定沿用当前文件的后缀名
	 * @return List Map(用户查看文件名，数据库存放的路径)localPath, strBaseServicePath,
	 *         protjectID, ""
	 *//*
	public List<Map<String, Object>> uploadFile(String localPath,
			String baseServicePath, String protjectID, String nameSuffix) {
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		String strServicePath = "";
		boolean flag;
		flag = connectServer();// 连接ftp
		boolean blCreateDir = createDir(baseServicePath);
		if (blCreateDir) {
			Map<String, Object> mapData = new HashMap<String, Object>();
			// 如果没有指定后缀名，则沿用当前文件的后缀名
			if ("".equals(nameSuffix))
				nameSuffix = localPath.substring(localPath.lastIndexOf("."));
			strServicePath = baseServicePath + "/" + protjectID + nameSuffix;
			upFile(localPath, "/" + this.path + "/" + strServicePath);// 上传到ftp
			mapData.put("ServicePath", strServicePath);
			list.add(mapData);
		}
		closeServer();
		return list;
	}

	*//**
	 * 连接ftp服务器
	 * 
	 * @throws IOException
	 *//*
	private boolean connectServer() { // 私有的
		ftpClient = new FtpClient();
		try {
			if (this.port != -1) {
				ftpClient.openServer(this.ip, this.port);
			} else {
				ftpClient.openServer(this.ip);
			}
			ftpClient.login(this.username, this.password);
			if (this.path.length() != 0) {
				ftpClient.cd(this.path);// path是ftp服务下主目录的子目录
			}
			ftpClient.binary();// 用2进制上传、下载
			// //System.out.println("已登录到\"" + ftpClient.pwd() + "\"目录");
			return true;
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
	}

	*//**
	 * 断开与ftp服务器连接
	 * 
	 * @throws IOException
	 *//*
	private boolean closeServer() {
		try {
			if (is != null) {
				is.close();
			}
			if (os != null) {
				os.close();
			}
			if (ftpClient != null) {
				ftpClient.closeServer();
			}
			return true;
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
	}

	*//**
	 * 检查文件夹在当前目录下是否存在
	 * 
	 * @param dir
	 * @return
	 *//*
	private boolean isDirExist(String dir) {
		String pwd = "";
		try {
			pwd = ftpClient.pwd();
			ftpClient.cd(dir);
			ftpClient.cd(pwd);
		} catch (Exception e) {
			return false;
		}
		return true;
	}

	*//**
	 * 在当前目录下创建文件夹
	 * 
	 * @param dir
	 * @return
	 * @throws Exception
	 *//*
	private boolean createDir(String dir) {
		try {
			ftpClient.ascii();
			StringTokenizer s = new StringTokenizer(dir, "/"); // sign
			s.countTokens();
			String pathName = ftpClient.pwd();
			while (s.hasMoreElements()) {
				pathName = pathName + "/" + (String) s.nextElement();
				// System.out.println(pathName);
				try {
					ftpClient.sendServer("MKD " + pathName + "\r\n");
				} catch (Exception e) {
					e = null;
					return false;
				}
				ftpClient.readServerResponse();
			}
			ftpClient.binary();
			return true;
		} catch (IOException e1) {
			e1.printStackTrace();
			return false;
		}
	}

	*//**
	 * ftp上传 如果服务器段已存在名为filename的文件夹，该文件夹中与要上传的文件夹中同名的文件将被替换
	 * 
	 * @param filename
	 *            要上传的文件（或文件夹）名
	 * @return
	 * @throws Exception
	 *//*
	private boolean upload(String filename) {
		String newname = "";
		if (filename.indexOf("/") > -1) {
			newname = filename.substring(filename.lastIndexOf("/") + 1);
		} else {
			newname = filename;
		}
		return upload(filename, newname);
	}

	*//**
	 * ftp上传 如果服务器段已存在名为newName的文件夹，该文件夹中与要上传的文件夹中同名的文件将被替换
	 * 
	 * @param fileName
	 *            要上传的文件（或文件夹）名
	 * @param newName
	 *            服务器段要生成的文件（或文件夹）名
	 * @return
	 *//*
	private boolean upload(String fileName, String newName) {
		try {
			String savefilename = new String(fileName.getBytes("GBK"), "GBK");
			File file_in = new File(savefilename);// 打开本地待长传的文件
			if (!file_in.exists()) {
				throw new Exception("此文件或文件夹[" + file_in.getName() + "]有误或不存在!");
			}
			// file_in.isDirectory() true时表示上传的为整个目录，false时表示上传的是文档
			if (file_in.isDirectory()) {
				upload(file_in.getPath(), newName, ftpClient.pwd());
			} else {
				uploadFile(file_in.getPath(), newName);
			}
			if (is != null) {
				is.close();
			}
			if (os != null) {
				os.close();
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			System.err.println("Exception e in Ftp upload(): " + e.toString());
			return false;
		} finally {
			try {
				if (is != null) {
					is.close();
				}
				if (os != null) {
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	*//**
	 * 真正用于上传的方法
	 * 
	 * @param fileName
	 * @param newName
	 * @param path
	 * @throws Exception
	 *//*
	private void upload(String fileName, String newName, String path)
			throws Exception {
		String savefilename = new String(fileName.getBytes("ISO-8859-1"), "GBK");
		File file_in = new File(savefilename);// 打开本地待长传的文件
		if (!file_in.exists()) {
			throw new Exception("此文件或文件夹[" + file_in.getName() + "]有误或不存在!");
		}
		if (file_in.isDirectory()) {
			if (!isDirExist(newName)) {
				createDir(newName);
			}
			ftpClient.cd(newName);
			File sourceFile[] = file_in.listFiles();
			for (int i = 0; i < sourceFile.length; i++) {
				if (!sourceFile[i].exists()) {
					continue;
				}
				if (sourceFile[i].isDirectory()) {
					this.upload(sourceFile[i].getPath(),
							sourceFile[i].getName(), path + "/" + newName);
				} else {
					// //System.out.println("###path="+path+ "/" + newName+ "/"
					// +sourceFile[i].getName());
					mapPathName.put(
							path + "/" + newName + "/"
									+ sourceFile[i].getName(),
							sourceFile[i].getName());
					this.uploadFile(sourceFile[i].getPath(),
							sourceFile[i].getName());
				}
			}
		} else {
			uploadFile(file_in.getPath(), newName);
		}
		ftpClient.cd(path);
	}

	*//**
	 * upload 上传文件
	 * 
	 * @param filename
	 *            要上传的文件名
	 * @param newname
	 *            上传后的新文件名
	 * @return -1 文件不存在 >=0 成功上传，返回文件的大小
	 * @throws Exception
	 *//*
	private long uploadFile(String filename, String newname) throws Exception {
		long result = 0;
		TelnetOutputStream os = null;
		FileInputStream is = null;
		try {
			java.io.File file_in = new java.io.File(filename);
			if (!file_in.exists())
				return -1;
			os = ftpClient.put(newname);
			result = file_in.length();
			is = new FileInputStream(file_in);
			byte[] bytes = new byte[1024];
			int c;
			while ((c = is.read(bytes)) != -1) {
				os.write(bytes, 0, c);
			}
		} finally {
			if (is != null) {
				is.close();
			}
			if (os != null) {
				os.close();
			}
		}
		return result;
	}

	*//**
	 * 从ftp下载文件到本地
	 * 
	 * @param filename
	 *            服务器上的文件名
	 * @param newfilename
	 *            本地生成的文件名
	 * @return
	 * @throws Exception
	 *//*
	public long downloadFile(String filename, String newfilename) {
		long result = 0;
		TelnetInputStream is = null;
		FileOutputStream os = null;
		try {
			is = ftpClient.get(filename);
			java.io.File outfile = new java.io.File(newfilename);
			os = new FileOutputStream(outfile);
			byte[] bytes = new byte[1024];
			int c;
			while ((c = is.read(bytes)) != -1) {
				os.write(bytes, 0, c);
				result = result + c;
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null) {
					is.close();
				}
				if (os != null) {
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return result;
	}

	public boolean downloadFiles(String filename, String newfilename) {
		boolean flag = false;
		int len = 0;
		byte[] bytes = new byte[1024];
		sun.net.TelnetInputStream finput = null;
		java.io.OutputStream outputStream = null;
		connectServer();
		try {

			ServletActionContext.getResponse().setCharacterEncoding("UTF-8");
			ServletActionContext.getResponse().setContentType(
					"application/octet-stream");
			ServletActionContext.getResponse().addHeader(
					"Content-Disposition",
					"attachment; filename="
							+ java.net.URLEncoder.encode(newfilename, "UTF-8")
									.replace("+", " "));
			finput = getServiceFile(filename);
			outputStream = ServletActionContext.getResponse().getOutputStream();
			while ((len = finput.read(bytes)) != -1) {
				outputStream.write(bytes, 0, len);
			}
			outputStream.flush();
			finput.close();
			outputStream.close();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (finput != null) {
					finput.close();
				}
				if (outputStream != null) {
					outputStream.close();
				}
				closeServer();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return flag;
	}

	private TelnetInputStream getServiceFile(String filename) {
		TelnetInputStream is = null;
		try {
			is = ftpClient.get(filename);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return is;
	}

	*//**
	 * 取得相对于当前连接目录的某个目录下所有文件列表
	 * 
	 * @param path
	 * @return
	 *//*
	private List getFileList(String path) {
		List list = new ArrayList();
		DataInputStream dis;
		try {
			dis = new DataInputStream(ftpClient.nameList(this.path + path));
			String filename = "";
			while ((filename = dis.readLine()) != null) {
				list.add(filename);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return list;
	}

	*//**
	 * 上传文件到FTP服务器,destination路径以FTP服务器的"/"开始，带文件名、 上传文件只能使用二进制模式，当文件存在时再次上传则会覆盖
	 * 
	 * @param source
	 *            String
	 * @param destination
	 *            String
	 * @throws Exception
	 *//*
	private void upFile(String source, String destination) {
		try {
			buildList(destination.substring(0, destination.lastIndexOf("/")));
			ftpClient.binary(); // 此行代码必须放在buildList之后
			TelnetOutputStream ftpOut = ftpClient.put(destination);
			TelnetInputStream ftpIn = new TelnetInputStream(
					new FileInputStream(source), true);
			byte[] buf = new byte[204800];
			int bufsize = 0;
			while ((bufsize = ftpIn.read(buf, 0, buf.length)) != -1) {
				ftpOut.write(buf, 0, bufsize);
			}
			ftpIn.close();
			ftpOut.close();
			if (is != null) {
				is.close();
			}
			if (os != null) {
				os.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
			System.err.println("Exception e in Ftp upload(): " + e.toString());
		} finally {
			try {
				if (is != null) {
					is.close();
				}
				if (os != null) {
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	*//**
	 * JSP中的流上传到FTP服务器, 上传文件只能使用二进制模式，当文件存在时再次上传则会覆盖 字节数组做为文件的输入流,此方法适用于JSP中通过
	 * request输入流来直接上传文件在RequestUpload类中调用了此方法， destination路径以FTP服务器的"/"开始，带文件名
	 * 
	 * @param sourceData
	 *            byte[]
	 * @param destination
	 *            String
	 * @throws Exception
	 *//*
	private void upFile(byte[] sourceData, String destination) throws Exception {
		buildList(destination.substring(0, destination.lastIndexOf("/")));
		ftpClient.binary(); // 此行代码必须放在buildList之后
		TelnetOutputStream ftpOut = ftpClient.put(destination);
		ftpOut.write(sourceData, 0, sourceData.length);
		// ftpOut.flush();
		ftpOut.close();
	}

	*//**
	 * 从FTP文件服务器上下载文件SourceFileName，到本地destinationFileName 所有的文件名中都要求包括完整的路径名在内
	 * 
	 * @param SourceFileName
	 *            String
	 * @param destinationFileName
	 *            String
	 * @throws Exception
	 *//*
	public void downFile(String SourceFileName, String destinationFileName)
			throws Exception {
		connectServer();
		ftpClient.binary(); // 一定要使用二进制模式
		TelnetInputStream ftpIn = ftpClient.get(SourceFileName);
		byte[] buf = new byte[204800];
		int bufsize = 0;
		FileOutputStream ftpOut = new FileOutputStream(destinationFileName);
		while ((bufsize = ftpIn.read(buf, 0, buf.length)) != -1) {
			ftpOut.write(buf, 0, bufsize);
		}
		closeServer();
		ftpOut.close();
		ftpIn.close();
	}

	*//**
	 * 从FTP文件服务器上下载文件，输出到字节数组中
	 * 
	 * @param SourceFileName
	 *            String
	 * @return byte[]
	 * @throws Exception
	 *//*
	public byte[] downFile(String SourceFileName) throws Exception {
		connectServer();
		ftpClient.binary(); // 一定要使用二进制模式
		TelnetInputStream ftpIn = ftpClient.get(SourceFileName);
		ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
		byte[] buf = new byte[204800];
		int bufsize = 0;
		while ((bufsize = ftpIn.read(buf, 0, buf.length)) != -1) {
			byteOut.write(buf, 0, bufsize);
		}
		byte[] return_arraybyte = byteOut.toByteArray();
		byteOut.close();
		ftpIn.close();
		closeServer();
		return return_arraybyte;
	}

	*//**
	 * 从FTP文件服务器上下载文件，输出到字节数组中
	 * 
	 * @param SourceFileName
	 *            String by Arison 20130706
	 * @return byte[]
	 * @throws Exception
	 *//*
	public byte[] downFile(String SourceFileName, String destinationFileName,
			String suffix) throws Exception {
		ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
		byte[] buf = new byte[204800];
		int bufsize = 0;
		connectServer();
		ftpClient.binary(); // 一定要使用二进制模式
		TelnetInputStream ftpIn = ftpClient.get(SourceFileName);
		while ((bufsize = ftpIn.read(buf, 0, buf.length)) != -1) {
			byteOut.write(buf, 0, bufsize);
		}
		byte[] return_arraybyte = byteOut.toByteArray();
		byteOut.close();
		ftpIn.close();
		closeServer();
		return return_arraybyte;
	}

	*//**
	 * 在FTP服务器上建立指定的目录,当目录已经存在的情下不会影响目录下的文件,这样用以判断FTP
	 * 上传文件时保证目录的存在目录格式必须以"/"根目录开头
	 * 
	 * @param pathList
	 *            String
	 * @throws Exception
	 *//*
	private void buildList(String pathList) throws Exception {
		ftpClient.ascii();
		StringTokenizer s = new StringTokenizer(pathList, "/"); // sign
		int count = s.countTokens();
		String pathName = "";
		while (s.hasMoreElements()) {
			pathName = pathName + "/" + (String) s.nextElement();
			try {
				ftpClient.sendServer("XMKD " + pathName + "\r\n");
			} catch (Exception e) {
				e = null;
			}
			int reply = ftpClient.readServerResponse();
		}
		ftpClient.binary();
	}
	public boolean moveFile(String oldFile, String newFile) throws IOException {
		boolean flag = false;
		ftpClient.rename(oldFile, newFile);
		flag = true;
		return flag;
	}

	public boolean moveFiles(String oldFile, String newFile) {
		boolean flag = false;
		connectServer();
		try {
			boolean blCreateDir = createDir(newFile.substring(0,
					newFile.lastIndexOf("/")));
			if (blCreateDir) {
				flag = moveFile(oldFile, newFile);
			}
			closeServer();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {

			closeServer();
		}
		return flag;
	}

	private Map<String, String> getMapPathName() {
		return mapPathName;
	}

	private void setMapPathName(Map<String, String> mapPathName) {
		this.mapPathName = mapPathName;
	}

	// public static FtpUtil getFtpUtil(){
	// return new FtpUtil("172.16.21.25", "liuyang", "liuyang");
	// }
	// //FtpUtil.getFtpUtil().upload();
	// public static void main(String[] args) {
	// 文档上传
	// FtpUtil ftp = new
	// FtpUtil("172.16.21.10","public","dagong",21,"dagongCRFile");
	// Date date = new Date();
	// String strDir = "aasdAAAAfsadf/ssadfasdf/";
	// String strFileName = "E:/Temp/实体注释.doc";
	//
	// String strNameSuffix=strFileName.substring(strFileName.lastIndexOf("."));
	// //System.out.println("strNameSuffix="+strNameSuffix);
	// ftp.connectServer();
	// ftp.createDir(strDir);
	// boolean result = ftp.upload(strFileName,
	// strDir+date.getTime()+strNameSuffix);
	// //System.out.println(result ? "上传成功！" : "上传失败！");
	// ftp.closeServer();
	// /**
	// * FTP远程命令列表 USER PORT RETR ALLO DELE SITE XMKD CDUP FEAT PASS PASV STOR
	// * REST CWD STAT RMD XCUP OPTS ACCT TYPE APPE RNFR XCWD HELP XRMD STOU
	// * AUTH REIN STRU SMNT RNTO LIST NOOP PWD SIZE PBSZ QUIT MODE SYST ABOR
	// * NLST MKD XPWD MDTM PROT
	// * 在服务器上执行命令,如果用sendServer来执行远程命令(不能执行本地FTP命令)的话，所有FTP命令都要加上\r\n
	// * ftpclient.sendServer("XMKD /test/bb\r\n"); //执行服务器上的FTP命令
	// * ftpclient.readServerResponse一定要在sendServer后调用
	// * nameList("/test")获取指目录下的文件列表 XMKD建立目录，当目录存在的情况下再次创建目录时报错 XRMD删除目录
	// * DELE删除文件
	// */

	// 文档下载
	// FtpUtil ftp = new
	// FtpUtil("172.16.21.10","public","dagong",21,"dagongCRFile");
	// ftp.connectServer();
	// String filename = "/Report/China/GJ00000000011341392564248.doc";
	// String newfilename = "E:/Temp/a.doc";
	// //String strSheetID =
	// this.getServletRequest().getAttribute("").toString();
	//
	// long lgResult = ftp.downloadFile(filename, newfilename);
	// ftp.closeServer();
	
	/**
	 * 文件删除
	 */
	/*public void delete(String filename) {
		connectServer();
		ftpClient.sendServer("DELE " + filename + "\r\n");
		closeServer();
	}
    private void publishValue() {
		// System.out.println("***************");
		// System.out.println("ip="+this.ip+",username="+this.username+",password="+this.password+",path="+this.path+",port="+this.port);
		// System.out.println("***************");
	}

	public static void main(String[] args) {
		FtpUtil f = new FtpUtil("10.10.10.132", 21, "dagong", "dagong");
		f.uploadFile("d:/11.txt", "/sdf/fdf", ".txt");
	}*/

//}